1 /*
2 * Copyright (c) 2021-2022 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 "zone_util.h"
18
19 using namespace OHOS::Global::I18n;
20 using testing::ext::TestSize;
21 using namespace std;
22
23 namespace OHOS {
24 namespace Global {
25 namespace I18n {
26 class ZoneUtilTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32 };
33
SetUpTestCase(void)34 void ZoneUtilTest::SetUpTestCase(void)
35 {}
36
TearDownTestCase(void)37 void ZoneUtilTest::TearDownTestCase(void)
38 {}
39
SetUp(void)40 void ZoneUtilTest::SetUp(void)
41 {
42 }
43
TearDown(void)44 void ZoneUtilTest::TearDown(void)
45 {}
46
47 /**
48 * @tc.name: ZoneUtilFuncTest001
49 * @tc.desc: Test ZoneUtil GetDefaultZone
50 * @tc.type: FUNC
51 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest001, TestSize.Level1)52 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest001, TestSize.Level1)
53 {
54 string expects[] = { "Asia/Shanghai", "America/New_York", "Asia/Shanghai", "America/New_York", "", "" };
55 string countries[] = { "CN", "US", "cn", "us", "fake", "GB" };
56 ZoneUtil util;
57 int count = 4;
58 for (int i = 0; i < count; ++i) {
59 string out = util.GetDefaultZone(countries[i].c_str());
60 EXPECT_EQ(out, expects[i]);
61 }
62 }
63
64 /**
65 * @tc.name: ZoneUtilFuncTest002
66 * @tc.desc: Test ZoneUtil GetDefaultZone with offset
67 * @tc.type: FUNC
68 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest002, TestSize.Level1)69 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest002, TestSize.Level1)
70 {
71 string expects[] = { "Asia/Shanghai", "America/Detroit", "" };
72 int32_t offsets[] = { 3600 * 1000 * 8, -3600 * 1000 * 5, 1234 * 789 * 7 };
73 string countries[] = { "CN", "US", "fake" };
74 int count = 2;
75 ZoneUtil util;
76 for (int i = 0; i < count; ++i) {
77 string out = util.GetDefaultZone(countries[i].c_str(), offsets[i]);
78 EXPECT_EQ(out, expects[i]);
79 }
80 }
81
82 /**
83 * @tc.name: ZoneUtilFuncTest003
84 * @tc.desc: Test ZoneUtil GetDefaultZoneList for CN
85 * @tc.type: FUNC
86 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest003, TestSize.Level1)87 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest003, TestSize.Level1)
88 {
89 vector<string> expects = { "Asia/Shanghai", "Asia/Urumqi"};
90 string country = "CN";
91 vector<string> out;
92 ZoneUtil util;
93 util.GetZoneList(country, out);
94 EXPECT_EQ(expects.size(), out.size());
95 if (expects.size() == out.size()) {
96 for (decltype(expects.size()) i = 0; i < expects.size(); ++i) {
97 EXPECT_EQ(expects[i], out[i]);
98 }
99 }
100
101 country = "fake";
102 out.clear();
103 util.GetZoneList(country, out);
104 EXPECT_EQ(out.size(), 0);
105 }
106
107 /**
108 * @tc.name: ZoneUtilFuncTest004
109 * @tc.desc: Test ZoneUtil GetDefaultZoneList for GB
110 * @tc.type: FUNC
111 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest004, TestSize.Level1)112 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest004, TestSize.Level1)
113 {
114 vector<string> expects = { "Europe/London" };
115 string country = "GB";
116 vector<string> out;
117 ZoneUtil util;
118 util.GetZoneList(country, out);
119 EXPECT_EQ(expects.size(), out.size());
120 if (expects.size() == out.size()) {
121 for (decltype(expects.size()) i = 0; i < expects.size(); ++i) {
122 EXPECT_EQ(expects[i], out[i]);
123 }
124 }
125 }
126
127 /**
128 * @tc.name: ZoneUtilFuncTest003
129 * @tc.desc: Test ZoneUtil GetDefaultZoneList for de
130 * @tc.type: FUNC
131 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest005, TestSize.Level1)132 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest005, TestSize.Level1)
133 {
134 vector<string> expects = { "Europe/Berlin", "Europe/Busingen" };
135 string country = "DE";
136 vector<string> out;
137 ZoneUtil util;
138 util.GetZoneList(country, out);
139 EXPECT_EQ(expects.size(), out.size());
140 if (expects.size() == out.size()) {
141 for (decltype(expects.size()) i = 0; i < expects.size(); ++i) {
142 EXPECT_EQ(expects[i], out[i]);
143 }
144 }
145 }
146
147 /**
148 * @tc.name: ZoneUtilFuncTest006
149 * @tc.desc: Test ZoneUtil GetDefaultZoneList for CN with offset 8 hours
150 * @tc.type: FUNC
151 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest006, TestSize.Level1)152 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest006, TestSize.Level1)
153 {
154 vector<string> expects = { "Asia/Shanghai" };
155 string country = "CN";
156 vector<string> out;
157 ZoneUtil util;
158 util.GetZoneList(country, 3600 * 1000 * 8, out);
159 EXPECT_EQ(expects.size(), out.size());
160 if (expects.size() == out.size()) {
161 for (decltype(expects.size()) i = 0; i < expects.size(); ++i) {
162 EXPECT_EQ(expects[i], out[i]);
163 }
164 }
165
166 country = "fake";
167 out.clear();
168 util.GetZoneList(country, 1234 * 789 * 9, out);
169 EXPECT_EQ(out.size(), 0);
170 }
171
172 /**
173 * @tc.name: ZoneUtilFuncTest007
174 * @tc.desc: Test ZoneUtil GetDefaultZoneList for 86 with offset 8 hours
175 * @tc.type: FUNC
176 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest007, TestSize.Level1)177 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest007, TestSize.Level1)
178 {
179 vector<string> expects = { "Asia/Shanghai" };
180 int32_t number = 86;
181 ZoneUtil util;
182 string out = util.GetDefaultZone(number);
183 EXPECT_EQ(expects[0], out);
184 int32_t fakeNum = 2233;
185 out = util.GetDefaultZone(fakeNum);
186 EXPECT_EQ("", out);
187 }
188
189 /**
190 * @tc.name: ZoneUtilFuncTest008
191 * @tc.desc: Test ZoneUtil GetDefaultZoneList for 86 with offset 8 hours
192 * @tc.type: FUNC
193 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest008, TestSize.Level1)194 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest008, TestSize.Level1)
195 {
196 vector<string> expects = { "Asia/Shanghai" };
197 int32_t number = 86;
198 ZoneUtil util;
199 string out = util.GetDefaultZone(number, 8 * 3600 * 1000);
200 EXPECT_EQ(expects[0], out);
201 int32_t fakeNum = 2233;
202 out = util.GetDefaultZone(fakeNum, 8 * 3600 * 1000);
203 EXPECT_EQ("", out);
204 }
205
206 /**
207 * @tc.name: ZoneUtilFuncTest009
208 * @tc.desc: Test ZoneUtil LookupTimezoneByCountryAndNITZ
209 * @tc.type: FUNC
210 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest009, TestSize.Level1)211 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest009, TestSize.Level1)
212 {
213 ZoneUtil util;
214 std::string region = "CN";
215 NITZData nitzData = { 0, 28800000, 1679969021999 };
216 CountryResult result = util.LookupTimezoneByCountryAndNITZ(region, nitzData);
217 EXPECT_TRUE(result.isOnlyMatch);
218 EXPECT_EQ(result.timezoneId, "Asia/Shanghai");
219
220 NITZData nitzData2 = { 0, 21600000, 1679969021999 };
221 CountryResult result2 = util.LookupTimezoneByCountryAndNITZ(region, nitzData2);
222 EXPECT_TRUE(result2.isOnlyMatch);
223 EXPECT_EQ(result2.timezoneId, "Asia/Urumqi");
224 }
225
226 /**
227 * @tc.name: ZoneUtilFuncTest010
228 * @tc.desc: Test ZoneUtil LookupTimezoneByNITZ
229 * @tc.type: FUNC
230 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest010, TestSize.Level1)231 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest010, TestSize.Level1)
232 {
233 ZoneUtil util;
234
235 NITZData nitzData = { 0, 28800000, 1679969021999 };
236 CountryResult result = util.LookupTimezoneByNITZ(nitzData);
237 EXPECT_FALSE(result.isOnlyMatch);
238 unordered_set<std::string> possibleTimeZones = {"Asia/Shanghai", "Asia/Urumqi", "Antarctica/Casey", "Asia/Brunei",
239 "Asia/Choibalsan", "Asia/Hong_Kong", "Asia/Irkutsk", "Asia/Kuala_Lumpur", "Asia/Kuching", "Asia/Macau",
240 "Asia/Makassar", "Asia/Manila", "Asia/Shanghai", "Asia/Singapore", "Asia/Taipei", "Asia/Ulaanbaatar",
241 "Australia/Perth"};
242 EXPECT_TRUE(possibleTimeZones.find(result.timezoneId) != possibleTimeZones.end());
243
244 NITZData nitzData2 = { 1, 10800000, 1679969021999 };
245 CountryResult result2 = util.LookupTimezoneByNITZ(nitzData2);
246 EXPECT_FALSE(result2.isOnlyMatch);
247 possibleTimeZones = {"Asia/Beirut", "Asia/Famagusta", "Asia/Jerusalem", "Asia/Nicosia", "EET",
248 "Europe/Athens", "Europe/Bucharest", "Europe/Chisinau", "Europe/Helsinki", "Europe/Kiev", "Europe/Mariehamn",
249 "Europe/Nicosia", "Europe/Riga", "Europe/Sofia", "Europe/Tallinn", "Europe/Uzhgorod", "Europe/Vilnius",
250 "Europe/Zaporozhye"};
251 EXPECT_TRUE(possibleTimeZones.find(result2.timezoneId) != possibleTimeZones.end());
252
253 NITZData nitzData3 = { 1, 37800000, 1679969021999 };
254 CountryResult result3 = util.LookupTimezoneByNITZ(nitzData3);
255 EXPECT_FALSE(result3.isOnlyMatch);
256 possibleTimeZones = {"Australia/Adelaide", "Australia/Broken_Hill"};
257 EXPECT_TRUE(possibleTimeZones.find(result3.timezoneId) != possibleTimeZones.end());
258
259 NITZData nitzData4 = { 0, 12345678, 1679969021999 };
260 CountryResult result4 = util.LookupTimezoneByNITZ(nitzData4);
261 EXPECT_TRUE(result4.isOnlyMatch);
262 EXPECT_EQ(result4.timezoneId, "");
263
264 NITZData nitzData5 = { -1, 12345678, 1679969021999 };
265 CountryResult result5 = util.LookupTimezoneByNITZ(nitzData5);
266 EXPECT_TRUE(result5.isOnlyMatch);
267 EXPECT_EQ(result5.timezoneId, "");
268 }
269
270 /**
271 * @tc.name: ZoneUtilFuncTest011
272 * @tc.desc: Test ZoneUtil LookupTimezoneByCountry
273 * @tc.type: FUNC
274 */
HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest011, TestSize.Level1)275 HWTEST_F(ZoneUtilTest, ZoneUtilFuncTest011, TestSize.Level1)
276 {
277 ZoneUtil util;
278 std::string region = "AQ";
279 int64_t currentMillis = 1679969021999;
280 CountryResult result = util.LookupTimezoneByCountry(region, currentMillis);
281 EXPECT_EQ(result.timezoneId, "Antarctica/McMurdo");
282 EXPECT_EQ(result.quality, MatchQuality::MULTIPLE_ZONES_DIFFERENT_OFFSET);
283
284 region = "fake Region";
285 CountryResult result2 = util.LookupTimezoneByCountry(region, currentMillis);
286 EXPECT_EQ(result2.timezoneId, "");
287 EXPECT_EQ(result2.quality, 3);
288
289 region = "AR";
290 CountryResult result3 = util.LookupTimezoneByCountry(region, currentMillis);
291 EXPECT_EQ(result3.timezoneId, "America/Argentina/Buenos_Aires");
292 EXPECT_TRUE(result3.quality == 0 || result3.quality == 2);
293
294 region = "AM";
295 CountryResult result4 = util.LookupTimezoneByCountry(region, currentMillis);
296 EXPECT_EQ(result4.timezoneId, "Asia/Yerevan");
297 EXPECT_EQ(result4.quality, 1);
298
299 region = "CY";
300 CountryResult result5 = util.LookupTimezoneByCountry(region, currentMillis);
301 EXPECT_EQ(result5.timezoneId, "Asia/Nicosia");
302 EXPECT_EQ(result5.quality, 2);
303 }
304 } // namespace I18n
305 } // namespace Global
306 } // namespace OHOS