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 <memory>
17 #include <iostream>
18 #include "gtest/gtest.h"
19 #include "media_dfx.h"
20 #include "common/media_core.h"
21 #include "meta/meta.h"
22
23 using namespace testing::ext;
24 using namespace OHOS::Media;
25
26 namespace {
27 constexpr uint32_t TEST_UID_ID_1 = 1;
28 constexpr int32_t ERROR_CODE = 5;
29 }
30
31 namespace OHOS {
32 namespace Media {
33 class MediaDfxTest : public testing::Test {
34 public:
SetUpTestCase(void)35 static void SetUpTestCase(void) {};
TearDownTestCase(void)36 static void TearDownTestCase(void) {};
SetUp(void)37 void SetUp(void)
38 {
39 mediaEvent_ = std::make_shared<MediaEvent>();
40 };
TearDown(void)41 void TearDown(void)
42 {
43 mediaEvent_ = nullptr;
44 };
45
46 std::shared_ptr<MediaEvent> mediaEvent_ = nullptr;
47 };
48
HWTEST_F(MediaDfxTest, CREATE_MEDIA_INFO, TestSize.Level1)49 HWTEST_F(MediaDfxTest, CREATE_MEDIA_INFO, TestSize.Level1)
50 {
51 uint64_t instanceId = 1;
52 int32_t ret = CreateMediaInfo(CallType::AVPLAYER, TEST_UID_ID_1, instanceId);
53 ASSERT_EQ(ret, MSERR_OK);
54
55 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
56 meta->SetData(Tag::SCREEN_CAPTURE_ERR_MSG, "SCREEN_CAPTURE_ERR_MSG");
57 meta->SetData(Tag::SCREEN_CAPTURE_ERR_CODE, ERROR_CODE);
58 ret = AppendMediaInfo(meta, instanceId);
59 ASSERT_EQ(ret, MSERR_OK);
60
61 ret = ReportMediaInfo(instanceId);
62 ASSERT_EQ(ret, MSERR_OK);
63 }
64
HWTEST_F(MediaDfxTest, CREATE_MEDIA_INFO_1, TestSize.Level1)65 HWTEST_F(MediaDfxTest, CREATE_MEDIA_INFO_1, TestSize.Level1)
66 {
67 uint64_t instanceId = 1;
68 int32_t ret = CreateMediaInfo(CallType::AVPLAYER, TEST_UID_ID_1, instanceId);
69 ASSERT_EQ(ret, MSERR_OK);
70
71 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
72 meta->SetData(Tag::SCREEN_CAPTURE_ERR_MSG, "SCREEN_CAPTURE_ERR_MSG");
73 meta->SetData(Tag::SCREEN_CAPTURE_ERR_CODE, ERROR_CODE);
74 ret = AppendMediaInfo(meta, instanceId);
75 ASSERT_EQ(ret, MSERR_OK);
76
77 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
78 ret = AppendMediaInfo(meta1, instanceId);
79 ASSERT_NE(ret, MSERR_OK);
80 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
81
82 ret = ReportMediaInfo(instanceId);
83 ASSERT_EQ(ret, MSERR_OK);
84 }
85
HWTEST_F(MediaDfxTest, CREATE_MEDIA_INFO_2, TestSize.Level1)86 HWTEST_F(MediaDfxTest, CREATE_MEDIA_INFO_2, TestSize.Level1)
87 {
88 uint64_t instanceId = 1;
89 int32_t ret = CreateMediaInfo(CallType::AVPLAYER, TEST_UID_ID_1, instanceId);
90 ASSERT_EQ(ret, MSERR_OK);
91
92 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
93 meta->SetData(Tag::SCREEN_CAPTURE_ERR_MSG, "SCREEN_CAPTURE_ERR_MSG");
94 meta->SetData(Tag::SCREEN_CAPTURE_ERR_CODE, ERROR_CODE);
95 ret = AppendMediaInfo(meta, instanceId);
96 ASSERT_EQ(ret, MSERR_OK);
97
98 ret = ReportMediaInfo(instanceId);
99 ASSERT_EQ(ret, MSERR_OK);
100 ret = ReportMediaInfo(instanceId);
101 ASSERT_NE(ret, MSERR_OK);
102 ASSERT_EQ(ret, MSERR_INVALID_OPERATION);
103 }
104 #ifdef SUPPORT_JSON
105 // Scenario1: Test case for int32_t type
HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseInt32_WhenInt32Type, TestSize.Level0)106 HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseInt32_WhenInt32Type, TestSize.Level0) {
107 std::pair<uint64_t, std::shared_ptr<Meta>> listPair;
108 listPair.first = 1;
109 listPair.second = std::make_shared<Meta>();
110 listPair.second->SetData(Tag::APP_UID, 123);
111 json metaInfoJson;
112
113 mediaEvent_->ParseOneEvent(listPair, metaInfoJson);
114
115 EXPECT_EQ(metaInfoJson[Tag::APP_UID], "123");
116 }
117
118 // Scenario2: Test case for uint32_t type
HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseUint32_WhenUint32Type, TestSize.Level0)119 HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseUint32_WhenUint32Type, TestSize.Level0) {
120 std::pair<uint64_t, std::shared_ptr<Meta>> listPair;
121 listPair.first = 1;
122 listPair.second = std::make_shared<Meta>();
123 listPair.second->SetData(Tag::DRM_DECRYPT_AVG_SIZE, 456u);
124 json metaInfoJson;
125
126 mediaEvent_->ParseOneEvent(listPair, metaInfoJson);
127
128 EXPECT_EQ(metaInfoJson[Tag::DRM_DECRYPT_AVG_SIZE], "456");
129 }
130
131 // Scenario3: Test case for uint64_t type
HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseUint64_WhenUint64Type, TestSize.Level0)132 HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseUint64_WhenUint64Type, TestSize.Level0) {
133 std::pair<uint64_t, std::shared_ptr<Meta>> listPair;
134 listPair.first = 1;
135 listPair.second = std::make_shared<Meta>();
136 listPair.second->SetData(Tag::AV_PLAYER_DOWNLOAD_TOTAL_BITS, 789u);
137 json metaInfoJson;
138
139 mediaEvent_->ParseOneEvent(listPair, metaInfoJson);
140 Any valueType = OHOS::Media::GetDefaultAnyValue(Tag::AV_PLAYER_DOWNLOAD_TOTAL_BITS);
141 EXPECT_EQ(Any::IsSameTypeWith<uint64_t>(valueType), true);
142 }
143
144 // Scenario4: Test case for string type
HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseString_WhenStringType, TestSize.Level0)145 HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseString_WhenStringType, TestSize.Level0) {
146 std::pair<uint64_t, std::shared_ptr<Meta>> listPair;
147 listPair.first = 1;
148 listPair.second = std::make_shared<Meta>();
149 listPair.second->SetData(Tag::MIME_TYPE, "test");
150 json metaInfoJson;
151
152 mediaEvent_->ParseOneEvent(listPair, metaInfoJson);
153
154 EXPECT_EQ(metaInfoJson[Tag::MIME_TYPE], "test");
155 }
156
157 // Scenario5: Test case for int8_t type
HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseInt8_WhenInt8Type, TestSize.Level0)158 HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseInt8_WhenInt8Type, TestSize.Level0) {
159 std::pair<uint64_t, std::shared_ptr<Meta>> listPair;
160 listPair.first = 1;
161 listPair.second = std::make_shared<Meta>();
162 int8_t value = 100;
163 listPair.second->SetData(Tag::AV_PLAYER_HDR_TYPE, value);
164 json metaInfoJson;
165
166 mediaEvent_->ParseOneEvent(listPair, metaInfoJson);
167 Any valueType = OHOS::Media::GetDefaultAnyValue(Tag::AV_PLAYER_HDR_TYPE);
168 EXPECT_EQ(Any::IsSameTypeWith<int8_t>(valueType), true);
169 }
170
171 // Scenario6: Test case for bool type
HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseBool_WhenBoolType, TestSize.Level0)172 HWTEST_F(MediaDfxTest, ParseOneEvent_ShouldParseBool_WhenBoolType, TestSize.Level0) {
173
174 // test StatisicsHiSysEventWrite
175 std::vector<std::string> infoArr = {"test for tdd", "test for tdd"};
176 mediaEvent_->StatisicsHiSysEventWrite(CallType::AVPLAYER, OHOS::HiviewDFX::HiSysEvent::EventType::FAULT, infoArr);
177 mediaEvent_->StatisicsHiSysEventWrite(CallType::AVRECORDER, OHOS::HiviewDFX::HiSysEvent::EventType::FAULT, infoArr);
178 mediaEvent_->StatisicsHiSysEventWrite(CallType::SCREEN_CAPTRUER,
179 OHOS::HiviewDFX::HiSysEvent::EventType::FAULT, infoArr);
180 mediaEvent_->StatisicsHiSysEventWrite(CallType::AVTRANSCODER,
181 OHOS::HiviewDFX::HiSysEvent::EventType::FAULT, infoArr);
182 mediaEvent_->StatisicsHiSysEventWrite(CallType::METADATA_RETRIEVER,
183 OHOS::HiviewDFX::HiSysEvent::EventType::FAULT, infoArr);
184
185 std::pair<uint64_t, std::shared_ptr<Meta>> listPair;
186 listPair.first = 1;
187 listPair.second = std::make_shared<Meta>();
188 listPair.second->SetData(Tag::MEDIA_HAS_VIDEO, true);
189 json metaInfoJson;
190
191 mediaEvent_->ParseOneEvent(listPair, metaInfoJson);
192
193 EXPECT_EQ(metaInfoJson[Tag::MEDIA_HAS_VIDEO], "true");
194 }
195 #endif
196 }
197 }