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 #include <gtest/gtest.h>
16
17 #include "clipboard_policy_serializer_test.h"
18 #include "utils.h"
19
20 using namespace testing::ext;
21
22 namespace OHOS {
23 namespace EDM {
24 namespace TEST {
25 const std::string POLICY_DATA_ILLEGAL = "[{\"tokenId\":\"tokenId\",\"clipboardPolicy\":1},{\"clipboardPolicy\":2}]";
26 const std::string POLICY_DATA_ILLEGAL2 = "[{\"tokenId\":1,\"clipboardPolicy\":\"clipboardPolicy\"},{\"tokenId\":2}]";
27 const std::string POLICY_DATA = "[{\"tokenId\":1,\"clipboardPolicy\":3},{\"tokenId\":2,\"clipboardPolicy\":0}]";
SetUpTestSuite(void)28 void ClipboardPolicySerializerTest::SetUpTestSuite(void)
29 {
30 Utils::SetEdmInitialEnv();
31 }
32
TearDownTestSuite(void)33 void ClipboardPolicySerializerTest::TearDownTestSuite(void)
34 {
35 Utils::ResetTokenTypeAndUid();
36 ASSERT_TRUE(Utils::IsOriginalUTEnv());
37 std::cout << "now ut process is orignal ut env : " << Utils::IsOriginalUTEnv() << std::endl;
38 }
39
40 /**
41 * @tc.name: TestDeserializeEmpty
42 * @tc.desc: Test ClipboardSerializer::Deserialize when jsonString is empty
43 * @tc.type: FUNC
44 */
45 HWTEST_F(ClipboardPolicySerializerTest, TestDeserializeEmpty, TestSize.Level1)
46 {
47 auto serializer = ClipboardSerializer::GetInstance();
48 std::string jsonString;
49 std::map<int32_t, ClipboardPolicy> result;
50 bool ret = serializer->Deserialize(jsonString, result);
51 ASSERT_TRUE(ret);
52 ASSERT_TRUE(result.empty());
53 }
54
55 /**
56 * @tc.name: TestDeserializeIllegal
57 * @tc.desc: Test ClipboardSerializer::Deserialize when jsonString is illegal
58 * @tc.type: FUNC
59 */
60 HWTEST_F(ClipboardPolicySerializerTest, TestDeserializeIllegal, TestSize.Level1)
61 {
62 auto serializer = ClipboardSerializer::GetInstance();
63 std::string jsonString = POLICY_DATA_ILLEGAL;
64 std::map<int32_t, ClipboardPolicy> result;
65 bool ret = serializer->Deserialize(jsonString, result);
66 ASSERT_FALSE(ret);
67 ASSERT_TRUE(result.empty());
68 }
69
70 /**
71 * @tc.name: TestDeserializeIllegal2
72 * @tc.desc: Test ClipboardSerializer::Deserialize when jsonString is illegal
73 * @tc.type: FUNC
74 */
75 HWTEST_F(ClipboardPolicySerializerTest, TestDeserializeIllegal2, TestSize.Level1)
76 {
77 auto serializer = ClipboardSerializer::GetInstance();
78 std::string jsonString = POLICY_DATA_ILLEGAL2;
79 std::map<int32_t, ClipboardPolicy> result;
80 bool ret = serializer->Deserialize(jsonString, result);
81 ASSERT_FALSE(ret);
82 ASSERT_TRUE(result.empty());
83 }
84
85 /**
86 * @tc.name: TestDeserializeSuc
87 * @tc.desc: Test ClipboardSerializer::Deserialize
88 * @tc.type: FUNC
89 */
90 HWTEST_F(ClipboardPolicySerializerTest, TestDeserializeSuc, TestSize.Level1)
91 {
92 auto serializer = ClipboardSerializer::GetInstance();
93 std::string jsonString = POLICY_DATA;
94 std::map<int32_t, ClipboardPolicy> result;
95 bool ret = serializer->Deserialize(jsonString, result);
96 ASSERT_TRUE(ret);
97 ASSERT_TRUE(result.size() == 2);
98 }
99
100 /**
101 * @tc.name: TestSerializeEmpty
102 * @tc.desc: Test ClipboardSerializer::Serialize
103 * @tc.type: FUNC
104 */
105 HWTEST_F(ClipboardPolicySerializerTest, TestSerializeEmpty, TestSize.Level1)
106 {
107 auto serializer = ClipboardSerializer::GetInstance();
108 std::string jsonString;
109 std::map<int32_t, ClipboardPolicy> result;
110 bool ret = serializer->Serialize(result, jsonString);
111 ASSERT_TRUE(ret);
112 ASSERT_TRUE(jsonString.empty());
113 }
114
115 /**
116 * @tc.name: TestSerializeSuc
117 * @tc.desc: Test ClipboardSerializer::Serialize
118 * @tc.type: FUNC
119 */
120 HWTEST_F(ClipboardPolicySerializerTest, TestSerializeSuc, TestSize.Level1)
121 {
122 auto serializer = ClipboardSerializer::GetInstance();
123 std::string jsonString;
124 std::map<int32_t, ClipboardPolicy> result;
125 result.insert(std::make_pair(1, ClipboardPolicy::IN_APP));
126 bool ret = serializer->Serialize(result, jsonString);
127 ASSERT_TRUE(ret);
128 ASSERT_FALSE(jsonString.empty());
129 }
130
131 /**
132 * @tc.name: TestGetPolicySuc
133 * @tc.desc: Test ClipboardSerializer::GetPolicy
134 * @tc.type: FUNC
135 */
136 HWTEST_F(ClipboardPolicySerializerTest, TestGetPolicySuc, TestSize.Level1)
137 {
138 auto serializer = ClipboardSerializer::GetInstance();
139 MessageParcel data;
140 data.WriteInt32(1);
141 data.WriteInt32(3);
142 std::map<int32_t, ClipboardPolicy> result;
143 bool ret = serializer->GetPolicy(data, result);
144 ASSERT_TRUE(ret);
145 ASSERT_TRUE(result.size() == 1);
146 }
147
148 /**
149 * @tc.name: TestWritePolicySuc
150 * @tc.desc: Test ClipboardSerializer::WritePolicy
151 * @tc.type: FUNC
152 */
153 HWTEST_F(ClipboardPolicySerializerTest, TestWritePolicySuc, TestSize.Level1)
154 {
155 auto serializer = ClipboardSerializer::GetInstance();
156 MessageParcel reply;
157 std::map<int32_t, ClipboardPolicy> result;
158 bool ret = serializer->WritePolicy(reply, result);
159 ASSERT_TRUE(ret);
160 }
161
162 /**
163 * @tc.name: TestMergePolicySuc
164 * @tc.desc: Test ClipboardSerializer::MergePolicy
165 * @tc.type: FUNC
166 */
167 HWTEST_F(ClipboardPolicySerializerTest, TestMergePolicySuc, TestSize.Level1)
168 {
169 auto serializer = ClipboardSerializer::GetInstance();
170 std::vector<std::map<int32_t, ClipboardPolicy>> data;
171 std::map<int32_t, ClipboardPolicy> result;
172 data.push_back(result);
173 bool ret = serializer->MergePolicy(data, result);
174 ASSERT_TRUE(ret);
175 }
176
177 } // namespace TEST
178 } // namespace EDM
179 } // namespace OHOS