1 /*
2  * Copyright (C) 2023 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 <string>
18 #include "meta/any.h"
19 #include "meta/source_types.h"
20 #include "unittest_log.h"
21 #include <cstdlib>
22 
23 using namespace std;
24 using namespace testing::ext;
25 using namespace OHOS;
26 using namespace OHOS::Media;
27 
28 namespace OHOS {
29 namespace Media {
30 namespace AnyFuncUT {
31 class AnyInnerUnitTest : public testing::Test {
32 public:
33     static void SetUpTestCase(void);
34 
35     static void TearDownTestCase(void);
36 
37     void SetUp(void);
38 
39     void TearDown(void);
40 };
41 
SetUpTestCase(void)42 void AnyInnerUnitTest::SetUpTestCase(void) {}
43 
TearDownTestCase(void)44 void AnyInnerUnitTest::TearDownTestCase(void) {}
45 
SetUp(void)46 void AnyInnerUnitTest::SetUp(void)
47 {
48     std::cout << "[SetUp]: SetUp!!!, test: ";
49     const ::testing::TestInfo *testInfo_ = ::testing::UnitTest::GetInstance()->current_test_info();
50     std::string testName = testInfo_->name();
51     std::cout << testName << std::endl;
52 }
53 
TearDown(void)54 void AnyInnerUnitTest::TearDown(void)
55 {
56     std::cout << "[TearDown]: over!!!" << std::endl;
57 }
58 
59 /**
60  * @tc.name: Any_Init
61  * @tc.desc: Any_Init
62  * @tc.type: FUNC
63  */
64 HWTEST_F(AnyInnerUnitTest, Any_Init, TestSize.Level1)
65 {
66     Any anyInit = 123;
67     Any anyCopy(anyInit);
68     int32_t valueIn = AnyCast<int32_t>(anyInit);
69     int32_t valueOut = AnyCast<int32_t>(anyCopy);
70     EXPECT_EQ(valueOut, valueIn);
71 
72     Any anyInitValueType(Plugins::SrcInputType::AUD_MIC);
73     Plugins::SrcInputType valueOutSrcType = AnyCast<Plugins::SrcInputType>(anyInitValueType);
74     EXPECT_EQ(static_cast<int32_t>(valueOutSrcType), 1);
75 }
76 
77 /**
78  * @tc.name: Any_Move
79  * @tc.desc: Any_Move
80  * @tc.type: FUNC
81  */
82 HWTEST_F(AnyInnerUnitTest, Any_Move, TestSize.Level1)
83 {
84     Any anyInit = 124;
85     Any anyMove(std::move(anyInit));
86     int32_t valueOut = AnyCast<int32_t>(anyMove);
87     ASSERT_FALSE(anyInit.HasValue());
88     EXPECT_EQ(valueOut, 124);
89 }
90 
91 /**
92  * @tc.name: Any_Copy
93  * @tc.desc: Any_Copy
94  * @tc.type: FUNC
95  */
96 HWTEST_F(AnyInnerUnitTest, Any_Copy, TestSize.Level1)
97 {
98     Any anyInit = 125;
99     Any anyCopy(anyInit);
100     int32_t valueOut = AnyCast<int32_t>(anyInit);
101     int32_t valueOutCopy = AnyCast<int32_t>(anyInit);
102     ASSERT_TRUE(anyInit.HasValue());
103     EXPECT_EQ(valueOut, 125);
104     EXPECT_EQ(valueOutCopy, 125);
105 }
106 
107 /**
108  * @tc.name: Any_Swap
109  * @tc.desc: Any_Swap
110  * @tc.type: FUNC
111  */
112 HWTEST_F(AnyInnerUnitTest, Any_Swap, TestSize.Level1)
113 {
114     Any anyFirst = 125;
115     Any anySecond = 126;
116     anyFirst.Swap(anySecond);
117     int32_t valueOutFirst = AnyCast<int32_t>(anyFirst);
118     int32_t valueOutSecond = AnyCast<int32_t>(anySecond);
119     EXPECT_EQ(valueOutSecond, 125);
120     EXPECT_EQ(valueOutFirst, 126);
121     swap(anyFirst, anySecond);
122     valueOutFirst = AnyCast<int32_t>(anyFirst);
123     valueOutSecond = AnyCast<int32_t>(anySecond);
124     EXPECT_EQ(valueOutSecond, 126);
125     EXPECT_EQ(valueOutFirst, 125);
126 }
127 
128 /**
129  * @tc.name: Any_Cast
130  * @tc.desc: Any_Cast
131  * @tc.type: FUNC
132  */
133 HWTEST_F(AnyInnerUnitTest, Any_Cast, TestSize.Level1)
134 {
135     Any anyInt32 = 125;
136     int32_t valueOutInt32 = AnyCast<int32_t>(anyInt32);
137     EXPECT_EQ(valueOutInt32, 125);
138     Any anyInt64 = (int64_t)125000000001111L;
139     int64_t valueOutInt64 = AnyCast<int64_t>(anyInt64);
140     EXPECT_EQ(valueOutInt64, 125000000001111L);
141     Any anyBool = true;
142     bool valueOutbool = AnyCast<bool>(anyBool);
143     EXPECT_EQ(valueOutbool, true);
144     Any anyFloat = static_cast<float>(1.1);
145     float valueOutFloat = AnyCast<float>(anyFloat);
146     EXPECT_EQ(valueOutFloat, static_cast<float>(1.1));
147     Any anyDouble = static_cast<double>(1.2533);
148     double valueOutDouble = AnyCast<double>(anyDouble);
149     ASSERT_DOUBLE_EQ(valueOutDouble, static_cast<double>(1.2533));
150     std::string str = "test string";
151     Any anyString = str;
152     std::string valueOutString = AnyCast<std::string>(anyString);
153     EXPECT_EQ(valueOutString, str);
154     std::vector<uint8_t> vecUint8{1, 2, 3};
155     Any anyVecUInt8 = vecUint8;
156     std::vector<uint8_t> valueOutVecUInt8 = AnyCast<std::vector<uint8_t>>(anyVecUInt8);
157     EXPECT_EQ(valueOutVecUInt8, vecUint8);
158 }
159 
160 /**
161 * @tc.name: Any_IsSameTypeWith
162 * @tc.desc: Any_IsSameTypeWith
163 * @tc.type: FUNC
164 */
165 HWTEST_F(AnyInnerUnitTest, Any_IsSameTypeWith, TestSize.Level1)
166 {
167     Any anyInt32 = 125;
168     std::string_view strIntTypeName = anyInt32.GetTypeName<int32_t>();
169     std::string_view strInt = std::string_view("int");
170     EXPECT_EQ(strIntTypeName, strInt);
171     ASSERT_TRUE(Any::IsSameTypeWith<int32_t>(anyInt32));
172 
173     Any anyInt64 = (int64_t)125000000001111L;
174     ASSERT_TRUE(Any::IsSameTypeWith<int64_t>(anyInt64));
175 
176     Any anyBool = true;
177     ASSERT_TRUE(Any::IsSameTypeWith<bool>(anyBool));
178     std::string_view strBoolTypeName = anyBool.GetTypeName<bool>();
179     std::string_view strBool = std::string_view("bool");
180     EXPECT_EQ(strBoolTypeName, strBool);
181 
182     Any anyFloat = (float)1.1;
183     ASSERT_TRUE(Any::IsSameTypeWith<float>(anyFloat));
184     std::string_view strFloatTypeName = anyFloat.GetTypeName<float>();
185     std::string_view strFloat = std::string_view("float");
186     EXPECT_EQ(strFloatTypeName, strFloat);
187 
188     Any anyDouble = (double)1.2533;
189     ASSERT_TRUE(Any::IsSameTypeWith<double>(anyDouble));
190     std::string_view strDoubleTypeName = anyDouble.GetTypeName<double>();
191     std::string_view strDouble = std::string_view("double");
192     EXPECT_EQ(strDoubleTypeName, strDouble);
193 
194     std::string str = "test string";
195     Any anyString = str;
196     ASSERT_TRUE(Any::IsSameTypeWith<std::string>(anyString));
197 
198     std::vector<uint8_t> vecUint8{1, 2, 3};
199     Any anyVecUInt8 = vecUint8;
200     std::string_view strVecUint8TypeName = anyVecUInt8.GetTypeName<std::vector<uint8_t>>();
201     std::string_view strVecUint8 = std::string_view("std::vector<unsigned char>");
202     EXPECT_EQ(strVecUint8TypeName, strVecUint8);
203     ASSERT_TRUE(Any::IsSameTypeWith<std::vector<uint8_t>>(anyVecUInt8));
204 }
205 
206 /**
207  * @tc.name: Any_Parcel
208  * @tc.desc: Any_Parcel
209  * @tc.type: FUNC
210  */
211 HWTEST_F(AnyInnerUnitTest, Any_Parcel, TestSize.Level1)
212 {
213     MessageParcel metaParcel;
214     Any anyInt = 125;
215     anyInt.ToParcel(metaParcel);
216     Any anyIntParcel(0);
217     anyIntParcel.FromParcel(metaParcel);
218     int32_t valueOutNew = AnyCast<int32_t>(anyIntParcel);
219     EXPECT_EQ(valueOutNew, 125);
220 }
221 } // namespace AnyFuncUT
222 } // namespace Media
223 } // namespace OHOS
224