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 #include <gtest/gtest.h>
16
17 #include "telephony_call_policy_serializer_test.h"
18 #include "edm_constants.h"
19 #include "utils.h"
20
21 using namespace testing::ext;
22
23 namespace OHOS {
24 namespace EDM {
25 namespace TEST {
SetUpTestSuite(void)26 void TelephonyCallPolicySerializerTest::SetUpTestSuite(void)
27 {
28 Utils::SetEdmInitialEnv();
29 }
30
TearDownTestSuite(void)31 void TelephonyCallPolicySerializerTest::TearDownTestSuite(void)
32 {
33 Utils::ResetTokenTypeAndUid();
34 ASSERT_TRUE(Utils::IsOriginalUTEnv());
35 std::cout << "now ut process is orignal ut env : " << Utils::IsOriginalUTEnv() << std::endl;
36 }
37
38 /**
39 * @tc.name: TestSerializeEmpty
40 * @tc.desc: Test TelephonyCallPolicySerializerTest::Serialize when jsonString is empty
41 * @tc.type: FUNC
42 */
43 HWTEST_F(TelephonyCallPolicySerializerTest, TestSerializeEmpty, TestSize.Level1)
44 {
45 auto serializer = TelephonyCallPolicySerializer::GetInstance();
46 std::string jsonString;
47 std::map<std::string, TelephonyCallPolicyType> dataObj;
48 bool ret = serializer->Serialize(dataObj, jsonString);
49 ASSERT_TRUE(ret);
50 }
51
52 /**
53 * @tc.name: TestSerializeSuc
54 * @tc.desc: Test TelephonyCallPolicySerializerTest::Serialize
55 * @tc.type: FUNC
56 */
57 HWTEST_F(TelephonyCallPolicySerializerTest, TestSerializeSuc, TestSize.Level1)
58 {
59 auto serializer = TelephonyCallPolicySerializer::GetInstance();
60 std::string jsonString;
61 std::map<std::string, TelephonyCallPolicyType> dataObj;
62 TelephonyCallPolicyType info;
63 info.policyFlag = 0;
64 info.numberList.push_back("111111");
65 dataObj["incoming"] = info;
66 bool ret = serializer->Serialize(dataObj, jsonString);
67 ASSERT_TRUE(ret);
68 ASSERT_FALSE(jsonString.empty());
69 }
70
71 /**
72 * @tc.name: TestDeserializeWithEmptyString
73 * @tc.desc: Test TelephonyCallPolicySerializerTest::Deserialize jsonString is empty
74 * @tc.type: FUNC
75 */
76 HWTEST_F(TelephonyCallPolicySerializerTest, TestDeserializeWithEmptyString, TestSize.Level1)
77 {
78 auto serializer = TelephonyCallPolicySerializer::GetInstance();
79 std::string jsonString = "";
80 std::map<std::string, TelephonyCallPolicyType> dataObj;
81 bool ret = serializer->Deserialize(jsonString, dataObj);
82 ASSERT_TRUE(ret);
83 }
84
85 /**
86 * @tc.name: TestDeserializeRootIsNotArray
87 * @tc.desc: Test TelephonyCallPolicySerializerTest::Deserialize RootIsNotArray
88 * @tc.type: FUNC
89 */
90 HWTEST_F(TelephonyCallPolicySerializerTest, TestDeserializeRootIsNotArray, TestSize.Level1)
91 {
92 auto serializer = TelephonyCallPolicySerializer::GetInstance();
93 std::string jsonString = R"({"key": "value"})";
94 std::map<std::string, TelephonyCallPolicyType> dataObj;
95 bool ret = serializer->Deserialize(jsonString, dataObj);
96 ASSERT_FALSE(ret);
97 }
98
99 /**
100 * @tc.name: TestDeserializeSuc
101 * @tc.desc: Test TelephonyCallPolicySerializerTest::Deserialize
102 * @tc.type: FUNC
103 */
104 HWTEST_F(TelephonyCallPolicySerializerTest, TestDeserializeSuc, TestSize.Level1)
105 {
106 auto serializer = TelephonyCallPolicySerializer::GetInstance();
107 std::string jsonString = R"({"incoming":{"policyFlag":0,"numberList":["11111111"]}})";
108 std::map<std::string, TelephonyCallPolicyType> dataObj;
109 bool ret = serializer->Deserialize(jsonString, dataObj);
110 ASSERT_TRUE(ret);
111 ASSERT_EQ(dataObj.size(), 1);
112 }
113
114 /**
115 * @tc.name: TestMergePolicy
116 * @tc.desc: Test TelephonyCallPolicySerializerTest::MergePolicy
117 * @tc.type: FUNC
118 */
119 HWTEST_F(TelephonyCallPolicySerializerTest, TestMergePolicy, TestSize.Level1)
120 {
121 auto serializer = TelephonyCallPolicySerializer::GetInstance();
122 std::vector<std::map<std::string, TelephonyCallPolicyType>> dataObj;
123 std::map<std::string, TelephonyCallPolicyType> data;
124 TelephonyCallPolicyType info;
125 info.policyFlag = 0;
126 info.numberList.push_back("111111");
127 data["incoming"] = info;
128 dataObj.push_back(data);
129 std::map<std::string, TelephonyCallPolicyType> result;
130 serializer->MergePolicy(dataObj, result);
131 ASSERT_TRUE(result.size() == 1);
132 }
133
134 /**
135 * @tc.name: TestMergePolicy
136 * @tc.desc: Test TelephonyCallPolicySerializerTest::MergePolicy
137 * @tc.type: FUNC
138 */
139 HWTEST_F(TelephonyCallPolicySerializerTest, TestMergePolicy002, TestSize.Level1)
140 {
141 auto serializer = TelephonyCallPolicySerializer::GetInstance();
142 std::vector<std::map<std::string, TelephonyCallPolicyType>> dataObj;
143 std::map<std::string, TelephonyCallPolicyType> data;
144 TelephonyCallPolicyType info;
145 info.policyFlag = 0;
146 info.numberList.push_back("111111");
147 data["incoming"] = info;
148 dataObj.push_back(data);
149 std::map<std::string, TelephonyCallPolicyType> result;
150 result["incoming"] = info;
151 serializer->MergePolicy(dataObj, result);
152 ASSERT_TRUE(result.size() == 1);
153 }
154 } // namespace TEST
155 } // namespace EDM
156 } // namespace OHOS